home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Graphics / Ghostscript / source / gsbitops.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-01-01  |  17.9 KB  |  602 lines
  1. /* Copyright (C) 1994, 1995, 1996, 1997 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* gsbitops.c */
  20. /* Bitmap filling, copying, and transforming operations */
  21. #include "stdio_.h"
  22. #include "memory_.h"
  23. #include "gdebug.h"
  24. #include "gstypes.h"
  25. #include "gsbitops.h"
  26.  
  27. /*
  28.  * Define a compile-time option to reverse nibble order in alpha maps.
  29.  * Note that this does not reverse bit order within nibbles.
  30.  * This option is here for a very specialized purpose and does not
  31.  * interact well with the rest of the code.
  32.  */
  33. #ifndef ALPHA_LSB_FIRST
  34. #  define ALPHA_LSB_FIRST 0
  35. #endif
  36.  
  37. /* ---------------- Bit-oriented operations ---------------- */
  38.  
  39. /* Define masks for little-endian operation. */
  40. /* masks[i] has the first i bits off and the rest on. */
  41. #if !arch_is_big_endian
  42. const bits16 mono_copy_masks[17] = {
  43.     0xffff, 0xff7f, 0xff3f, 0xff1f,
  44.     0xff0f, 0xff07, 0xff03, 0xff01,
  45.     0xff00, 0x7f00, 0x3f00, 0x1f00,
  46.     0x0f00, 0x0700, 0x0300, 0x0100,
  47.     0x0000
  48. };
  49. #  if arch_sizeof_int > 2
  50. const bits32 mono_fill_masks[33] = {
  51.     0xffffffff, 0xffffff7f, 0xffffff3f, 0xffffff1f,
  52.     0xffffff0f, 0xffffff07, 0xffffff03, 0xffffff01,
  53.     0xffffff00, 0xffff7f00, 0xffff3f00, 0xffff1f00,
  54.     0xffff0f00, 0xffff0700, 0xffff0300, 0xffff0100,
  55.     0xffff0000, 0xff7f0000, 0xff3f0000, 0xff1f0000,
  56.     0xff0f0000, 0xff070000, 0xff030000, 0xff010000,
  57.     0xff000000, 0x7f000000, 0x3f000000, 0x1f000000,
  58.     0x0f000000, 0x07000000, 0x03000000, 0x01000000,
  59.     0x00000000
  60. };
  61. #  endif
  62. #endif
  63.  
  64. /* Fill a rectangle of bits with an 8x1 pattern. */
  65. /* The pattern argument must consist of the pattern in every byte, */
  66. /* e.g., if the desired pattern is 0xaa, the pattern argument must */
  67. /* have the value 0xaaaa (if ints are short) or 0xaaaaaaaa. */
  68. #undef chunk
  69. #define chunk mono_fill_chunk
  70. #undef mono_masks
  71. #define mono_masks mono_fill_masks
  72. void
  73. bits_fill_rectangle(byte *dest, int dest_bit, uint draster,
  74.   mono_fill_chunk pattern, int width_bits, int height)
  75. {    uint bit;
  76.     chunk right_mask;
  77.  
  78. #define write_loop(stat)\
  79.  { int line_count = height;\
  80.    chunk *ptr = (chunk *)dest;\
  81.    do { stat; inc_ptr(ptr, draster); }\
  82.    while ( --line_count );\
  83.  }
  84.  
  85. #define write_partial(msk)\
  86.   switch ( (byte)pattern )\
  87.   { case 0: write_loop(*ptr &= ~msk); break;\
  88.     case 0xff: write_loop(*ptr |= msk); break;\
  89.     default: write_loop(*ptr = (*ptr & ~msk) | (pattern & msk));\
  90.   }
  91.  
  92.     dest += (dest_bit >> 3) & -chunk_align_bytes;
  93.     bit = dest_bit & chunk_align_bit_mask;
  94.  
  95. #if 1            /* new code */
  96.  
  97. #define write_span(lmsk, stat0, statx, stat1, n, rmsk)\
  98.   switch ( (byte)pattern )\
  99.   { case 0: write_loop((*ptr &= ~lmsk, stat0, ptr[n] &= ~rmsk)); break;\
  100.     case 0xff: write_loop((*ptr |= lmsk, stat1, ptr[n] |= rmsk)); break;\
  101.     default: write_loop((*ptr = (*ptr & ~lmsk) | (pattern & lmsk), statx,\
  102.              ptr[n] = (ptr[n] & ~rmsk) | (pattern & rmsk)));\
  103.   }
  104.  
  105.     { int last_bit = width_bits + bit - (chunk_bits + 1);
  106.       if ( last_bit < 0 )        /* <=1 chunk */
  107.         { set_mono_thin_mask(right_mask, width_bits, bit);
  108.           write_partial(right_mask);
  109.         }
  110.       else
  111.         { chunk mask;
  112.           int last = last_bit >> chunk_log2_bits;
  113.           set_mono_left_mask(mask, bit);
  114.           set_mono_right_mask(right_mask, (last_bit & chunk_bit_mask) + 1);
  115.           switch ( last )
  116.         {
  117.         case 0:            /* 2 chunks */
  118.           { write_span(mask, 0, 0, 0, 1, right_mask);
  119.           } break;
  120.         case 1:            /* 3 chunks */
  121.           { write_span(mask, ptr[1] = 0, ptr[1] = pattern,
  122.                    ptr[1] = ~(chunk)0, 2, right_mask);
  123.           } break;
  124.         default:        /* >3 chunks */
  125.           { uint byte_count = (last_bit >> 3) & -chunk_bytes;
  126.             write_span(mask, memset(ptr + 1, 0, byte_count),
  127.                    memset(ptr + 1, (byte)pattern, byte_count),
  128.                    memset(ptr + 1, 0xff, byte_count),
  129.                    last + 1, right_mask);
  130.           } break;
  131.         }
  132.         }
  133.     }
  134.  
  135. #else            /* old code */
  136.  
  137.     if ( bit + width_bits <= chunk_bits )
  138.        {    /* Only one word. */
  139.         set_mono_thin_mask(right_mask, width_bits, bit);
  140.        }
  141.     else
  142.        {    int byte_count;
  143.         if ( bit )
  144.            {    chunk mask;
  145.             set_mono_left_mask(mask, bit);
  146.             write_partial(mask);
  147.             inc_ptr(dest, chunk_bytes);
  148.             width_bits += bit - chunk_bits;
  149.            }
  150.         set_mono_right_mask(right_mask, width_bits & chunk_bit_mask);
  151.         if ( width_bits >= chunk_bits )
  152.           switch ( (byte_count = (width_bits >> 3) & -chunk_bytes) )
  153.         {
  154.         case chunk_bytes:
  155.             write_loop(*ptr = pattern);
  156.             inc_ptr(dest, chunk_bytes);
  157.             break;
  158.         case chunk_bytes * 2:
  159.             write_loop(ptr[1] = *ptr = pattern);
  160.             inc_ptr(dest, chunk_bytes * 2);
  161.             break;
  162.         default:
  163.             write_loop(memset(ptr, (byte)pattern, byte_count));
  164.             inc_ptr(dest, byte_count);
  165.             break;
  166.         }
  167.        }
  168.     if ( right_mask )
  169.         write_partial(right_mask);
  170.  
  171. #endif
  172.  
  173. }
  174.  
  175. /* Replicate a bitmap horizontally in place. */
  176. void
  177. bits_replicate_horizontally(byte *data, uint width, uint height,
  178.   uint raster, uint replicated_width, uint replicated_raster)
  179. {    /* The current algorithm is extremely inefficient. */
  180.     uint y;
  181.     for ( y = height; y-- > 0; )
  182.       {    const byte *orig_row = data + y * raster;
  183.         byte *tile_row = data + y * replicated_raster;
  184.         uint sx;
  185.         if ( !(width & 7) )
  186.         { uint wbytes = width >> 3;
  187.           for ( sx = wbytes; sx-- > 0; )
  188.             {    byte sb = orig_row[sx];
  189.             uint dx;
  190.             for ( dx = sx + (replicated_width >> 3); dx >= wbytes; )
  191.               tile_row[dx -= wbytes] = sb;
  192.             }
  193.         }
  194.         else
  195.           for ( sx = width; sx-- > 0; )
  196.             {    byte sm = orig_row[sx >> 3] & (0x80 >> (sx & 7));
  197.             uint dx;
  198.             for ( dx = sx + replicated_width; dx >= width;
  199.                 )
  200.               {    byte *dp =
  201.                   (dx -= width, tile_row + (dx >> 3));
  202.                 byte dm = 0x80 >> (dx & 7);
  203.                 if ( sm ) *dp |= dm;
  204.                 else *dp &= ~dm;
  205.               }
  206.             }
  207.       }
  208. }
  209.  
  210. /* Replicate a bitmap vertically in place. */
  211. void
  212. bits_replicate_vertically(byte *data, uint height, uint raster,
  213.   uint replicated_height)
  214. {    byte *dest = data;
  215.     uint h = replicated_height;
  216.     uint size = raster * height;
  217.  
  218.     while ( h > height )
  219.       {    memcpy(dest + size, dest, size);
  220.         dest += size;
  221.         h -= height;
  222.       }
  223. }
  224.  
  225. /* Find the bounding box of a bitmap. */
  226. /* Assume bits beyond the width are zero. */
  227. void
  228. bits_bounding_box(const byte *data, uint height, uint raster,
  229.   gs_int_rect *pbox)
  230. {    register const ulong *lp;
  231.     static const byte first_1[16] =
  232.       { 4, 3, 2,2, 1,1,1,1, 0,0,0,0,0,0,0,0 };
  233.     static const byte last_1[16] =
  234.       { 0,4,3,4,2,4,3,4,1,4,3,4,2,4,3,4 };
  235.  
  236.     /* Count trailing blank rows. */
  237.     /* Since the raster is a multiple of sizeof(long), */
  238.     /* we don't need to scan by bytes, only by longs. */
  239.  
  240.     lp = (const ulong *)(data + raster * height);
  241.     while ( (const byte *)lp > data && !lp[-1] )
  242.       --lp;
  243.     if ( (const byte *)lp == data )
  244.       {    pbox->p.x = pbox->q.x = pbox->p.y = pbox->q.y = 0;
  245.         return;
  246.       }
  247.     pbox->q.y = height = ((const byte *)lp - data + raster - 1) / raster;
  248.  
  249.     /* Count leading blank rows. */
  250.  
  251.     lp = (const ulong *)data;
  252.     while ( !*lp )
  253.       ++lp;
  254.     { uint n = ((const byte *)lp - data) / raster;
  255.       pbox->p.y = n;
  256.       if ( n )
  257.         height -= n, data += n * raster;
  258.     }
  259.  
  260.     /* Find the left and right edges. */
  261.     /* We know that the first and last rows are non-blank. */
  262.  
  263.     {    uint raster_longs = raster >> arch_log2_sizeof_long;
  264.         uint left = raster_longs - 1, right = 0;
  265.         ulong llong = 0, rlong = 0;
  266.         const byte *q;
  267.         uint h, n;
  268.  
  269.         for ( q = data, h = height; h-- > 0; q += raster )
  270.           {    /* Work from the left edge by longs. */
  271.             for ( lp = (const ulong *)q, n = 0;
  272.                   n < left && !*lp; lp++, n++
  273.                 )
  274.               ;
  275.             if ( n < left )
  276.               left = n, llong = *lp;
  277.             else
  278.               llong |= *lp;
  279.             /* Work from the right edge by longs. */
  280.             for ( lp = (const ulong *)(q + raster - sizeof(long)),
  281.                     n = raster_longs - 1;
  282.                   n > right && !*lp; lp--, n--
  283.                 )
  284.               ;
  285.             if ( n > right )
  286.               right = n, rlong = *lp;
  287.             else
  288.               rlong |= *lp;
  289.           }
  290.  
  291.         /* Do binary subdivision on edge longs.  We assume that */
  292.         /* sizeof(long) = 4 or 8. */
  293. #if arch_sizeof_long > 8
  294.         Error_longs_are_too_large();
  295. #endif
  296.  
  297. #if arch_is_big_endian
  298. #  define last_bits(n) ((1L << (n)) - 1)
  299. #  define shift_out_last(x,n) ((x) >>= (n))
  300. #  define right_justify_last(x,n) DO_NOTHING
  301. #else
  302. #  define last_bits(n) (-1L << ((arch_sizeof_long * 8) - (n)))
  303. #  define shift_out_last(x,n) ((x) <<= (n))
  304. #  define right_justify_last(x,n) (x) >>= ((arch_sizeof_long * 8) - (n))
  305. #endif
  306.  
  307.         left <<= arch_log2_sizeof_long + 3;
  308. #if arch_sizeof_long == 8
  309.         if ( llong & ~last_bits(32) ) shift_out_last(llong, 32);
  310.         else left += 32;
  311. #endif
  312.         if ( llong & ~last_bits(16) ) shift_out_last(llong, 16);
  313.         else left += 16;
  314.         if ( llong & ~last_bits(8) ) shift_out_last(llong, 8);
  315.         else left += 8;
  316.         right_justify_last(llong, 8);
  317.         if ( llong & 0xf0 )
  318.           left += first_1[(byte)llong >> 4];
  319.         else
  320.           left += first_1[(byte)llong] + 4;
  321.  
  322.         right <<= arch_log2_sizeof_long + 3;
  323. #if arch_sizeof_long == 8
  324.         if ( !(rlong & last_bits(32)) ) shift_out_last(rlong, 32);
  325.         else right += 32;
  326. #endif
  327.         if ( !(rlong & last_bits(16)) ) shift_out_last(rlong, 16);
  328.         else right += 16;
  329.         if ( !(rlong & last_bits(8)) ) shift_out_last(rlong, 8);
  330.         else right += 8;
  331.         right_justify_last(rlong, 8);
  332.         if ( !(rlong & 0xf) )
  333.           right += last_1[(byte)rlong >> 4];
  334.         else
  335.           right += last_1[(uint)rlong & 0xf] + 4;
  336.  
  337.         pbox->p.x = left;
  338.         pbox->q.x = right;
  339.     }
  340. }    
  341.  
  342. /* Count the number of 1-bits in a half-byte. */
  343. static const byte half_byte_1s[16] = {0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4};
  344. /* Count the number of trailing 1s in an up-to-5-bit value, -1. */
  345. static const byte bits5_trailing_1s[32] =
  346. { 0,0,0,1,0,0,0,2,0,0,0,1,0,0,0,3,0,0,0,1,0,0,0,2,0,0,0,1,0,0,0,4 };
  347. /* Count the number of leading 1s in an up-to-5-bit value, -1. */
  348. static const byte bits5_leading_1s[32] =
  349. { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,2,2,3,4 };
  350.  
  351. /*
  352.  * Compress a value between 0 and 2^M to a value between 0 and 2^N-1.
  353.  * Possible values of M are 1, 2, 3, or 4; of N are 1, 2, and 4.
  354.  * The name of the table is compress_count_M_N.
  355.  * As noted below, we require that N <= M.
  356.  */
  357. static const byte compress_1_1[3] =
  358.     { 0, 1, 1 };
  359. static const byte compress_2_1[5] =
  360.     { 0, 0, 1, 1, 1 };
  361. static const byte compress_2_2[5] =
  362.     { 0, 1, 2, 2, 3 };
  363. static const byte compress_3_1[9] =
  364.     { 0, 0, 0, 0, 1, 1, 1, 1, 1 };
  365. static const byte compress_3_2[9] =
  366.     { 0, 0, 1, 1, 2, 2, 2, 3, 3 };
  367. static const byte compress_4_1[17] =
  368.     { 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
  369. static const byte compress_4_2[17] =
  370.     { 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3 };
  371. static const byte compress_4_4[17] =
  372.     { 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 9,10,11,12,13,14,15 };
  373. /* The table of tables is indexed by log2(N) and then by M-1. */
  374. static const byte _ds *compress_tables[4][4] =
  375. {    { compress_1_1, compress_2_1, compress_3_1, compress_4_1 },
  376.     { 0, compress_2_2, compress_3_2, compress_4_2 },
  377.     { 0, 0, 0, compress_4_4 }
  378. };
  379.  
  380. /*
  381.  * Compress an XxY-oversampled bitmap to Nx1 by counting 1-bits.  The X and
  382.  * Y oversampling factors are 1, 2, or 4, but may be different.  N, the
  383.  * resulting number of (alpha) bits per pixel, may be 1, 2, or 4; we allow
  384.  * compression in place, in which case N must not exceed the X oversampling
  385.  * factor.  Width and height are the source dimensions, and hence reflect
  386.  * the oversampling; both are multiples of the relevant scale factor.  The
  387.  * same is true for srcx.
  388.  */
  389. void
  390. bits_compress_scaled(const byte *src, int srcx, uint width, uint height,
  391.   uint sraster, byte *dest, uint draster,
  392.   const gs_log2_scale_point *plog2_scale, int log2_out_bits)
  393. {    int log2_x = plog2_scale->x, log2_y = plog2_scale->y;
  394.     int xscale = 1 << log2_x;
  395.     int yscale = 1 << log2_y;
  396.     int out_bits = 1 << log2_out_bits;
  397.     int input_byte_out_bits;
  398.     byte input_byte_out_mask;
  399.     const byte _ds *table =
  400.       compress_tables[log2_out_bits][log2_x + log2_y - 1];
  401.     uint sskip = sraster << log2_y;
  402.     uint dwidth = (width >> log2_x) << log2_out_bits;
  403.     uint dskip = draster - ((dwidth + 7) >> 3);
  404.     uint mask = (1 << xscale) - 1;
  405.     uint count_max = 1 << (log2_x + log2_y);
  406.     /*
  407.      * For right now, we don't attempt to take advantage of the fact
  408.      * that the input is aligned.
  409.      */
  410.     const byte *srow = src + (srcx >> 3);
  411.     int in_shift_initial = 8 - xscale - (srcx & 7);
  412.     int in_shift_check = (out_bits <= xscale ? 8 - xscale : -1);
  413.     byte *d = dest;
  414.     uint h;
  415.  
  416.     if ( out_bits <= xscale )
  417.       input_byte_out_bits = out_bits << (3 - log2_x),
  418.       input_byte_out_mask = (1 << input_byte_out_bits) - 1;
  419.     for ( h = height; h; srow += sskip, h -= yscale )
  420.       {    const byte *s = srow;
  421. #if ALPHA_LSB_FIRST
  422. #  define out_shift_initial 0
  423. #  define out_shift_update(out_shift, nbits) ((out_shift += (nbits)) >= 8)
  424. #else
  425. #  define out_shift_initial (8 - out_bits)
  426. #  define out_shift_update(out_shift, nbits) ((out_shift -= (nbits)) < 0)
  427. #endif
  428.         int out_shift = out_shift_initial;
  429.         byte out = 0;
  430.         int in_shift = in_shift_initial;
  431.         int dw = 8 - (srcx & 7);
  432.         int w;
  433.  
  434.         /* Loop over source bytes. */
  435.         for ( w = width; w > 0; w -= dw, dw = 8 )
  436.           { int index;
  437.             int in_shift_final =
  438.               (w >= dw ? 0 : dw - w);
  439.             /*
  440.              * Check quickly for all-0s or all-1s, but only if each
  441.              * input byte generates no more than one output byte,
  442.              * we're at an input byte boundary, and we're processing
  443.              * an entire input byte (i.e., this isn't a final
  444.              * partial byte.)
  445.              */
  446.             if ( in_shift == in_shift_check && in_shift_final == 0 )
  447.               switch ( *s )
  448.               {
  449.               case 0:
  450.             for ( index = sraster; index != sskip; index += sraster )
  451.               if ( s[index] != 0 )
  452.                 goto p;
  453.             if ( out_shift_update(out_shift, input_byte_out_bits) )
  454.               *d++ = out, out_shift &= 7, out = 0;
  455.             s++;
  456.             continue;
  457. #if !ALPHA_LSB_FIRST            /* too messy to make it work */
  458.               case 0xff:
  459.             for ( index = sraster; index != sskip; index += sraster )
  460.               if ( s[index] != 0xff )
  461.                 goto p;
  462.             { int shift =
  463.                 (out_shift -= input_byte_out_bits) + out_bits;
  464.               if ( shift > 0 )
  465.                 out |= input_byte_out_mask << shift;
  466.               else
  467.                 { out |= input_byte_out_mask >> -shift;
  468.                   *d++ = out;
  469.                   out_shift += 8;
  470.                   out = input_byte_out_mask << (8 + shift);
  471.                 }
  472.             }
  473.             s++;
  474.             continue;
  475. #endif
  476.               default:
  477.             ;
  478.               }
  479. p:            /* Loop over source pixels within a byte. */
  480.             do
  481.               {    uint count;
  482.             for ( index = 0, count = 0; index != sskip;
  483.                   index += sraster
  484.                 )
  485.               count += half_byte_1s[(s[index] >> in_shift) & mask];
  486.             if ( count != 0 && table[count] == 0 )
  487.               { /* Look at adjacent cells to help prevent */
  488.                 /* dropouts. */
  489.                 uint orig_count = count;
  490.                 uint shifted_mask = mask << in_shift;
  491.                 byte in;
  492.                 if_debug3('B', "[B]count(%d,%d)=%d\n",
  493.                       (width - w) / xscale,
  494.                       (height - h) / yscale, count);
  495.                 if ( yscale > 1 )
  496.                   { /* Look at the next "lower" cell. */
  497.                 if ( h < height && (in = s[0] & shifted_mask) != 0 )
  498.                   { uint lower;
  499.                     for ( index = 0, lower = 0;
  500.                       -(index -= sraster) <= sskip &&
  501.                       (in &= s[index]) != 0;
  502.                     )
  503.                       lower += half_byte_1s[in >> in_shift];
  504.                     if_debug1('B', "[B]  lower adds %d\n",
  505.                           lower);
  506.                     if ( lower <= orig_count )
  507.                       count += lower;
  508.                   }
  509.                 /* Look at the next "higher" cell. */
  510.                 if ( h > yscale && (in = s[sskip - sraster] & shifted_mask) != 0 )
  511.                   { uint upper;
  512.                     for ( index = sskip, upper = 0;
  513.                       index < sskip << 1 &&
  514.                       (in &= s[index]) != 0;
  515.                       index += sraster
  516.                     )
  517.                       upper += half_byte_1s[in >> in_shift];
  518.                     if_debug1('B', "[B]  upper adds %d\n",
  519.                           upper);
  520.                     if ( upper < orig_count )
  521.                       count += upper;
  522.                   }
  523.                   }
  524.                 if ( xscale > 1 )
  525.                   { uint mask1 = (mask << 1) + 1;
  526.                 /* Look at the next cell to the left. */
  527.                 if ( w < width )
  528.                   { int lshift = in_shift + xscale - 1;
  529.                     uint left;
  530.                     for ( index = 0, left = 0;
  531.                       index < sskip; index += sraster
  532.                     )
  533.                       { uint bits =
  534.                       ((s[index - 1] << 8) +
  535.                        s[index]) >> lshift;
  536.                     left += bits5_trailing_1s[bits & mask1];
  537.                       }
  538.                     if_debug1('B', "[B]  left adds %d\n",
  539.                           left);
  540.                     if ( left < orig_count )
  541.                       count += left;
  542.                   }
  543.                 /* Look at the next cell to the right. */
  544.                 if ( w > xscale )
  545.                   { int rshift = in_shift - xscale + 8;
  546.                     uint right;
  547.                     for ( index = 0, right = 0;
  548.                       index < sskip; index += sraster
  549.                     )
  550.                       { uint bits =
  551.                       ((s[index] << 8) +
  552.                        s[index + 1]) >> rshift;
  553.                     right += bits5_leading_1s[(bits & mask1) << (4 - xscale)];
  554.                       }
  555.                     if_debug1('B', "[B]  right adds %d\n",
  556.                           right);
  557.                     if ( right <= orig_count )
  558.                       count += right;
  559.                   }
  560.                   }
  561.                 if ( count > count_max )
  562.                   count = count_max;
  563.               }
  564.             out += table[count] << out_shift;
  565.             if ( out_shift_update(out_shift, out_bits) )
  566.               *d++ = out, out_shift &= 7, out = 0;
  567.               }
  568.             while ( (in_shift -= xscale) >= in_shift_final );
  569.             s++, in_shift += 8;
  570.           }
  571.         if ( out_shift != out_shift_initial )
  572.           *d++ = out;
  573.         for ( w = dskip; w != 0; w-- )
  574.           *d++ = 0;
  575. #undef out_shift_initial
  576. #undef out_shift_update
  577.       }
  578. }
  579.  
  580. /* ---------------- Byte-oriented operations ---------------- */
  581.  
  582. /* Fill a rectangle of bytes. */
  583. void
  584. bytes_fill_rectangle(byte *dest, uint raster,
  585.   byte value, int width_bytes, int height)
  586. {    while ( height-- > 0 )
  587.       {    memset(dest, value, width_bytes);
  588.         dest += raster;
  589.       }
  590. }
  591.  
  592. /* Copy a rectangle of bytes. */
  593. void
  594. bytes_copy_rectangle(byte *dest, uint dest_raster,
  595.   const byte *src, uint src_raster, int width_bytes, int height)
  596. {    while ( height-- > 0 )
  597.       {    memcpy(dest, src, width_bytes);
  598.         src += src_raster;
  599.         dest += dest_raster;
  600.       }
  601. }
  602.